package classes.collection;


import org.junit.Test;

import java.util.*;

public class CollectionTest {
  @Test
  public void collectionTest() {
    Collection<Integer> integers = new ArrayList<>();
    //        添加元素
    integers.add(10);
    integers.add(20);
//        通过其他集合，构造新的集合
    Collection<Integer> integers2 = new ArrayList<>(integers);
    integers2.add(30);
//        将一个集合添加到另一个集合中
    integers.addAll(integers2);
//        获取集合大小
    System.out.println(integers.size());
//        清空
    System.out.println(integers2.isEmpty());
    integers2.clear();
    System.out.println(integers2.isEmpty());
//        是否包含某个元素
    System.out.println(integers.contains(10));
    System.out.println(integers.contains(100));
//        是否包含该集合的所有元素
    System.out.println(integers.containsAll(integers2));
    integers2.add(10);
    System.out.println(integers.containsAll(integers2));
//         删除，只会删除该集合找到的第一个元素
    System.out.println(integers);
    integers.remove(10);
    System.out.println(integers);
//      集合是否相等，逐个元素用equals比较。不是比较地址
    System.out.println(integers.equals(integers2));
    integers2.clear();
    integers2.add(20);
    integers2.add(10);
    integers2.add(20);
    integers2.add(30);
    System.out.println(integers.equals(integers2));
//        转换成数组
    Object[] objects = integers.toArray();
    System.out.println(Arrays.toString(objects));
//        获取该集合的哈希值
    System.out.println(integers.hashCode());
//        获取该集合的迭代对象
    Iterator<Integer> iterator = integers.iterator();
//        数组转换成集合
    Integer[] integerArray = new Integer[]{10, 20, 30, 40, 50, 60};
    integers = Arrays.asList(integerArray);  // 本质是一个ArrayList
    System.out.println(integers.toString());
//        遍历所有元素
    for (Integer integer : integers) {
      System.out.println(integer);
    }
  }

  @Test
  public void iteratorTest() {
    Integer[] integerArray = new Integer[]{10, 20, 30, 40, 10, 20, 50, 60};
    List<Integer> integers = Arrays.asList(integerArray);
//        获取迭代器
    Iterator<Integer> iterator = integers.iterator();
//        迭代器遍历。①判断是否还有下一个元素  ②指针下移  ③将下移以后集合位置上的元素返回
    while (iterator.hasNext()) {
      System.out.println(iterator.next());
    }
//      判断结果。因为myStr是局部变量，所以对它赋值，不会对数组内容改变。
    String[] str = new String[5];
    for (String myStr : str) {
      myStr = "atguigu";
      System.out.println(myStr);
    }
    for (int i = 0; i < str.length; i++) {
      System.out.println(str[i]); // null
    }
  }

  @Test
  public void listTest() {
//        除了Collection之外，List还自己实现了一些方法
    List<Integer> integers = new ArrayList<>();
//        重载add方法
    integers.add(0, 10);
    integers.add(0, 20);
    System.out.println(integers);
//      从index 1开始插入另一个集合的元素
    ArrayList<Integer> integers1 = new ArrayList<>(Arrays.asList(20, 30, 40));
    integers.addAll(1, integers1);
    System.out.println(integers);
//        根据index删除元素。当传入的是int的时候，按照index删除。当传入的是Integer时，按照元素的值删除
    integers.remove(0);
    integers.remove(Integer.valueOf(10));
    System.out.println(integers);
//      根据index，获取元素
    System.out.println(integers.get(2));

    integers.add(20);
//        获取第一个等于该元素值的位置
    System.out.println(integers);
    System.out.println(integers.indexOf(20));
//        获取最后一个等于该元素值的位置
    System.out.println(integers.lastIndexOf(20));

//        设置指定位置的值,并取出被替换的值
    Integer set = integers.set(1, 10);
    System.out.println(set);
//        取出List的子List 左闭右开
    System.out.println(integers.subList(1, 3));
//        输出的本质是一个ArrayList
    System.out.println(Arrays.asList(10, 20).getClass());
  }

  /**
   * 本质是一个双向链表
   */
  @Test
  public void linkedListTest() {
    LinkedList<Integer> integers = new LinkedList<>();
//        在头部插入内容
    integers.addFirst(10);
    integers.addFirst(20);
    integers.addFirst(30);
    System.out.println(integers);
//        在尾部插入内容
    integers.addLast(50);
    System.out.println(integers);
//        获取头部的第一个元素
    System.out.println(integers.getFirst());
//        获取尾部的第一个元素
    System.out.println(integers.getLast());
//        删除头节点
    System.out.println(integers.removeFirst());  // 返回被删除的对象
    System.out.println(integers);
//      删除尾节点
    System.out.println(integers.removeLast());
    System.out.println(integers);
  }

  /**
   * HashSet通过比较hashCode的值及equals比较两个对象是否相等.
   * 若hashCode不等,就不需要比较equals了;若hashCode相等,还需要再比较equals是否相等.
   * 因此,插入hashSet的对象的类,都需要重写hashCode()和equals
   * <p>
   * 底层也就是散列表
   * hashCode 的本质就是31*(31*ele[0]+ele[1])... 31
   * 31可以减少哈希冲突
   */
  @Test
  public void setTest() {
    Set<Integer> integers = new HashSet<>();
    integers.add(10);
    integers.add(20);
    integers.add(10); // 重复了,不可添加
    System.out.println(integers);
  }

  /**
   * TreeSet添加元素的时候,会自动从小到大排序.通过红黑树存储该值
   * TreeSet通过compareTo比较两个元素的值，当compareTo为0时，就不会重复添加。因此，TreeSet存储的类，需要重写compareTo
   */
  @Test
  public void treeSetTest() {
    TreeSet<Integer> integers = new TreeSet<>();
    integers.add(0);
    integers.add(20);
    integers.add(-10);
    integers.add(-20);
    integers.add(40);
    System.out.println(integers);
//        获取第一个值
    System.out.println(integers.first());
//        获取最后一个值
    System.out.println(integers.last());
  }

  @Test
  public void test() {
    ArrayList<Integer> integers = new ArrayList<>();
    Collections.addAll(integers, 1, 2, 3, 4, 5, 6, 7);
    List<Integer> integers1 = integers.subList(2, 4);
    Collections.shuffle(integers1);
    System.out.println(integers1);
    System.out.println(integers);
    Integer[] integers2 = integers.toArray(new Integer[0]);
    System.out.println(Arrays.toString(integers2));
  }

  @Test
  public void testStack() {
    LinkedList<Integer> stack = new LinkedList<>();

  }


}
